home *** CD-ROM | disk | FTP | other *** search
/ Aminet 22 / Aminet 22 (1997)(GTI - Schatztruhe)[!][Dec 1997].iso / Aminet / dev / src / ConfigFileSrc.lha / ConfigFileSrc12 / Library / Funcs / Write.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-10-02  |  8.4 KB  |  351 lines
  1. /*
  2. **        $PROJECT: ConfigFile.library
  3. **        $FILE: Write.c
  4. **        $DESCRIPTION: cf_Write() function
  5. **
  6. **        (C) Copyright 1996-1997 Marcel Karas
  7. **             All Rights Reserved.
  8. */
  9.  
  10. #include "StrConv.h"
  11. #include "WriteBuffer.h"
  12. #include "Read&Write.h"
  13.  
  14. IMPORT struct DosLibrary    * DOSBase;
  15.  
  16. VOID WriteShort ( iCFHeader * Header , WBHeader * WBH );
  17. VOID WriteASCII ( iCFHeader * Header , WBHeader * WBH );
  18.  
  19. /****** configfile.library/cf_Write ******************************************
  20. *
  21. *   NAME
  22. *        cf_Write -- Write a CF file new.
  23. *
  24. *   SYNOPSIS
  25. *        Result = cf_Write(Header,WriteMode,ErrorCode);
  26. *        D0                A0     D0        A1
  27. *
  28. *        BOOL cf_Write(CFHeader *,ULONG,ULONG *);
  29. *
  30. *   FUNCTION
  31. *        This function writes the CF file new. Note is the CF_HFLG_CHANGED
  32. *        flag in Header->Flags not set the file will be not writes new.
  33. *
  34. *   INPUTS
  35. *        Header - The Header of the file to write.
  36. *        WriteMode - Write modes and extra flags:
  37. *
  38. *                CF_WMODE_DEFAULT -- Writes the file in default format
  39. *                                    from Header->Flags.
  40. *                CF_WMODE_ASCII   -- Writes the file in ascii format.
  41. *                CF_WMODE_SHORT   -- Writes the file in short format.
  42. *
  43. *                Extra write flags: (V2)
  44. *
  45. *                CF_WFLG_WRITE_ALWAYS -- cf_Write() checks not if the
  46. *                                        CF_HFLG_CHANGED flag set and
  47. *                                        writes always the file.
  48. *
  49. *        ErrorCode - Contain an errorcode if the function returns FALSE
  50. *                    or NULL.
  51. *
  52. *                CF_WERR_UNKOWN        - Unkown failure.
  53. *                CF_WERR_ALLOC_WBUFFER - No memory for WriteBuffer.
  54. *
  55. *   RESULT
  56. *        Result - TRUE for success or in case of FALSE return, the ErrorCode
  57. *                 var can be read to obtain more.
  58. *
  59. *   SEE ALSO
  60. *        cf_Open(), cf_Close(), cf_Read(), <libraries/configfile.h>
  61. *
  62. ******************************************************************************
  63. *
  64. */
  65.  
  66. LibCall BOOL cf_Write ( REGA0 iCFHeader * Header , REGD0 ULONG Mode , REGA1 ULONG *ErrorCode )
  67. {
  68.     FuncDe(bug("cf_Write($%08lx,%ld,$%08lx)\n{\n", Header, Mode, ErrorCode));
  69.  
  70.     if ( ( Header->Flags & CF_HFLG_CHANGED ) || ( Mode & CF_WFLG_WRITE_ALWAYS ) )
  71.     {
  72.         WBHeader WBH;
  73.         ULONG    Error;
  74.  
  75.         Mode &= ~0xFFFFFFFCL;
  76.  
  77.         Seek (Header->FileHandle, 0, OFFSET_BEGINNING);
  78.  
  79.         if ( AllocWBuffer (Header, &WBH) )
  80.         {
  81.             if ( ( Mode == CF_WMODE_DEFAULT ) || ( Mode > CF_WMODE_ASCII ) )
  82.             {
  83.                 if ( Header->Flags & CF_HFLG_ASCII_FILE )
  84.                     Mode = CF_WMODE_ASCII;
  85.                 else if ( Header->Flags & CF_HFLG_SHORT_FILE )
  86.                     Mode = CF_WMODE_SHORT;
  87.                 else
  88.                     Mode = CF_WMODE_ASCII;
  89.             }
  90.  
  91.             if ( Mode == CF_WMODE_ASCII )
  92.                 WriteASCII (Header, &WBH);
  93.             else
  94.                 WriteShort (Header, &WBH);
  95.  
  96.             FreeWBuffer (&WBH);
  97.             Header->Flags &= ~CF_HFLG_CHANGED;
  98.  
  99.             if ( WBH.TotalWrite && ( WBH.TotalWrite < Header->Length ) )
  100.                 SetFileSize (Header->FileHandle, WBH.TotalWrite, OFFSET_BEGINNING);
  101.  
  102.             Header->Length = WBH.TotalWrite;
  103.  
  104.             Seek (Header->FileHandle, 5, OFFSET_BEGINNING);
  105.  
  106.             FuncDe(bug("   return(TRUE)\n}\n"));
  107.             return (TRUE);
  108.         }
  109.         else    Error = CF_WERR_ALLOC_WBUFFER;
  110.  
  111. OnError:
  112.         if ( ErrorCode ) *ErrorCode = Error;
  113.         FuncDe(bug("   return(FALSE) Error %ld\n}\n", Error));
  114.     }
  115.  
  116.     return (FALSE);
  117. }
  118.  
  119. VOID WriteShort ( iCFHeader * Header , WBHeader * WBH )
  120. {
  121.     iCFGroup        * GrpNode;
  122.     iCFArgument    * ArgNode;
  123.     iCFItem        * ItemNode;
  124.  
  125.     STRPTR BuffPtr = WBH->StartPtr;
  126.  
  127. #define WriteEnd()        CharInWBuff (CTRLB_END)
  128. #define WriteSub()        CharInWBuff (CTRLB_SUB)
  129.  
  130.     StrInWBuff ("CFFT\0", 5);
  131.  
  132.     if ( GrpNode = cf_LockGrpList (Header) )
  133.     {
  134.         while ( GrpNode = cf_NextGroup (GrpNode) )
  135.         {
  136.             StrInWBuff (GrpNode->Name - 1, *(GrpNode->Name - 1) + 1);
  137.             UpdWBuff();
  138.  
  139.             if ( ArgNode = cf_LockArgList (GrpNode) )
  140.             {
  141.                 WriteSub();
  142.  
  143.                 while ( ArgNode = cf_NextArgument (ArgNode) )
  144.                 {
  145.                     StrInWBuff (ArgNode->Name - 1, *(ArgNode->Name - 1) + 1);
  146.                     UpdWBuff();
  147.  
  148.                     if ( ItemNode = cf_LockItemList (ArgNode) )
  149.                     {
  150.                         WriteSub();
  151.  
  152.                         while ( ItemNode = cf_NextItem (ItemNode) )
  153.                         {
  154.                             if ( ItemNode->Type == CF_ITYP_STRING )
  155.                             {
  156.                                 CharInWBuff (TYP_STRING);
  157.                                 StrInWBuff (ItemNode->Contents.String - 1,
  158.                                             *(ItemNode->Contents.String - 1) + 1);
  159.                             }
  160.                             else if ( ItemNode->Type == CF_ITYP_NUMBER )
  161.                             {
  162.                                 UBYTE    TmpByte = (TYP_NUMBER | SType2Bin[ItemNode->SpecialType]);
  163.                                 ULONG    Number  = ItemNode->Contents.Number;
  164.  
  165.                                 if ( Number < 0x100L )
  166.                                 {
  167.                                     CharInWBuff (TmpByte | NUM_BYTE);
  168.                                     CharInWBuff (ItemNode->Contents.Number);
  169.                                 }
  170.                                 else if ( Number < 0x10000L )
  171.                                 {
  172.                                     CharInWBuff (TmpByte | NUM_WORD);
  173. #ifdef _M68020
  174.                                     *( (UWORD *)BuffPtr ) = Number;
  175.                                     BuffPtr += 2;
  176. #else
  177.                                     {
  178.                                         UBYTE *TmpWord = (UBYTE *)&Number;
  179.  
  180.                                         *BuffPtr++ = TmpWord[0];
  181.                                         *BuffPtr++ = TmpWord[1];
  182.                                     }
  183. #endif
  184.                                 }
  185.                                 else
  186.                                 {
  187.                                     CharInWBuff (TmpByte);
  188. #ifdef _M68020
  189.                                     *( (ULONG *)BuffPtr ) = Number;
  190.                                     BuffPtr += 4;
  191. #else
  192.                                     {
  193.                                         UBYTE *TmpLong = (UBYTE *)&Number;
  194.  
  195.                                         *BuffPtr++ = TmpLong[0];
  196.                                         *BuffPtr++ = TmpLong[1];
  197.                                         *BuffPtr++ = TmpLong[2];
  198.                                         *BuffPtr++ = TmpLong[3];
  199.                                     }
  200. #endif
  201.                                 }
  202.                             }
  203.                             else if ( ItemNode->Type == CF_ITYP_BOOL )
  204.                             {
  205.                                 UBYTE TmpByte = (TYP_BOOL | SType2Bin[ItemNode->SpecialType]);
  206.  
  207.                                 if ( ItemNode->Contents.Bool )
  208.                                     TmpByte |= BOOL_TRUE;
  209.  
  210.                                 CharInWBuff (TmpByte);
  211.                             }
  212.  
  213.                             UpdWBuff();
  214.                         }
  215.  
  216.                         WriteEnd();
  217.                         cf_UnlockItemList (ArgNode);
  218.                     }
  219.                 }
  220.  
  221.                 WriteEnd();
  222.                 cf_UnlockArgList (GrpNode);
  223.             }
  224.         }
  225.  
  226.         WriteEnd();
  227.         cf_UnlockGrpList (Header);
  228.     }
  229.  
  230.     Header->Flags    &= ~CF_HFLG_ASCII_FILE;
  231.     Header->Flags    |= CF_HFLG_SHORT_FILE;
  232.  
  233.     WBH->LastPtr = BuffPtr;
  234. }
  235.  
  236. VOID WriteASCII ( iCFHeader * Header , WBHeader * WBH )
  237. {
  238.     iCFGroup        * GrpNode;
  239.     iCFArgument    * ArgNode;
  240.     iCFItem        * ItemNode;
  241.  
  242.     BOOL        Point        = FALSE;
  243.     STRPTR    BuffPtr    = WBH->StartPtr;
  244.  
  245.     StrInWBuff ("CFFT\n", 5);
  246.     
  247.     if ( GrpNode = cf_LockGrpList (Header) )
  248.     {
  249.         while ( GrpNode = cf_NextGroup (GrpNode) )
  250.         {
  251.             CharInWBuff('\n');
  252.             CharInWBuff('[' );
  253.             StrInWBuff (GrpNode->Name, *(GrpNode->Name - 1));
  254.             CharInWBuff(']' );
  255.             CharInWBuff('\n');
  256.             CharInWBuff('\n');
  257.  
  258.             UpdWBuff();
  259.  
  260.             if ( ArgNode = cf_LockArgList (GrpNode) )
  261.             {    
  262.                 while ( ArgNode = cf_NextArgument (ArgNode) )
  263.                 {
  264.                     StrInWBuff (ArgNode->Name, *(ArgNode->Name - 1));
  265.                     UpdWBuff();
  266.  
  267.                     if ( ItemNode = cf_LockItemList (ArgNode) )
  268.                     {
  269.                         CharInWBuff('=');
  270.  
  271.                         while ( ItemNode = cf_NextItem (ItemNode) )
  272.                         {
  273.                             if ( Point ) CharInWBuff(',');
  274.  
  275.                             if ( ItemNode->Type == CF_ITYP_STRING )
  276.                             {
  277.                                 CharInWBuff('\"');
  278.                                 StrInWBuff (ItemNode->Contents.String,
  279.                                                     *(ItemNode->Contents.String - 1));
  280.                                 CharInWBuff('\"');
  281.     
  282.                                 Point = TRUE;
  283.                             }
  284.                             else if ( ItemNode->Type == CF_ITYP_NUMBER )
  285.                             {
  286.                                 if ( ItemNode->SpecialType == CF_STYP_NUM_DEC )
  287.                                     BuffPtr = LongToDecStr (ItemNode->Contents.Number, BuffPtr);
  288.  
  289.                                 else if ( ItemNode->SpecialType == CF_STYP_NUM_HEX )
  290.                                     BuffPtr = LongToHexStr (ItemNode->Contents.Number, BuffPtr);
  291.  
  292.                                 else if ( ItemNode->SpecialType == CF_STYP_NUM_BIN )
  293.                                     BuffPtr = LongToBinStr (ItemNode->Contents.Number, BuffPtr);
  294.  
  295.                                 Point = TRUE;    
  296.                             }
  297.                             else if ( ItemNode->Type == CF_ITYP_BOOL )
  298.                             {
  299.                                 ULONG        BoolLen;
  300.                                 STRPTR    BoolStr;
  301.  
  302.                                 if ( ItemNode->SpecialType == CF_STYP_BOOL_TRUE )
  303.                                 {
  304.                                     if ( ItemNode->Contents.Bool )
  305.                                         { BoolStr = "TRUE";  BoolLen = 4; }
  306.                                     else
  307.                                         { BoolStr = "FALSE"; BoolLen = 5; }
  308.                                 }
  309.                                 else if ( ItemNode->SpecialType == CF_STYP_BOOL_YES )
  310.                                 {
  311.                                     if ( ItemNode->Contents.Bool )
  312.                                         { BoolStr = "YES";    BoolLen = 3; }
  313.                                     else
  314.                                         { BoolStr = "NO";        BoolLen = 2; }
  315.                                 }
  316.                                 else 
  317.                                 {
  318.                                     if ( ItemNode->Contents.Bool )
  319.                                         { BoolStr = "ON";        BoolLen = 2; }
  320.                                     else
  321.                                         { BoolStr = "OFF";    BoolLen = 3; }
  322.                                 }
  323.  
  324.                                 StrInWBuff (BoolStr, BoolLen);
  325.  
  326.                                 Point = TRUE;
  327.                             }
  328.  
  329.                             UpdWBuff();
  330.                         }
  331.  
  332.                         cf_UnlockItemList (ArgNode);
  333.                         Point = 0;
  334.                     }
  335.  
  336.                     CharInWBuff('\n');
  337.                 }
  338.  
  339.                 cf_UnlockArgList (GrpNode);
  340.             }
  341.         }
  342.             
  343.         cf_UnlockGrpList (Header);
  344.     }
  345.  
  346.     Header->Flags    &= ~CF_HFLG_SHORT_FILE;
  347.     Header->Flags    |= CF_HFLG_ASCII_FILE;
  348.  
  349.     WBH->LastPtr = BuffPtr;
  350. }
  351.